home *** CD-ROM | disk | FTP | other *** search
/ Symantec Visual Cafe for Java 2.5 / symantec-visual-cafe-2.5-database-dev-edition.iso / Visual Cafe Pro v1.0 / VISCAFE.BIN / TreeView.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-06-19  |  13.1 KB  |  799 lines
  1. package symantec.itools.awt;
  2.  
  3. import java.awt.BorderLayout;
  4. import java.awt.Color;
  5. import java.awt.Component;
  6. import java.awt.Container;
  7. import java.awt.Dimension;
  8. import java.awt.Event;
  9. import java.awt.Font;
  10. import java.awt.FontMetrics;
  11. import java.awt.Graphics;
  12. import java.awt.Image;
  13. import java.awt.LayoutManager;
  14. import java.awt.Panel;
  15. import java.awt.Rectangle;
  16. import java.awt.Scrollbar;
  17. import java.util.Vector;
  18. import symantec.beans.Beans;
  19.  
  20. public class TreeView extends Panel {
  21.    public static final int CHILD = 0;
  22.    public static final int NEXT = 1;
  23.    public static final int LAST = 2;
  24.    public static final int SEL_CHANGED = 1006;
  25.    private TreeNode rootNode;
  26.    private TreeNode selectedNode;
  27.    private TreeNode topVisibleNode;
  28.    Scrollbar sbV;
  29.    int sbVPosition;
  30.    int sbVWidth;
  31.    long sbVTimer;
  32.    private int count;
  33.    private int viewCount;
  34.    private Color bgHighlightColor;
  35.    private Color fgHighlightColor;
  36.    private int viewHeight;
  37.    private int viewWidth;
  38.    private int viewWidest;
  39.    int cellSize;
  40.    int clickSize;
  41.    int imageInset;
  42.    int textInset;
  43.    int textBaseLine;
  44.    // $FF: renamed from: fm java.awt.FontMetrics
  45.    private FontMetrics field_0;
  46.    long timeMouseDown;
  47.    int doubleClickResolution;
  48.    protected Image im1;
  49.    // $FF: renamed from: g1 java.awt.Graphics
  50.    protected Graphics field_1;
  51.    // $FF: renamed from: e java.util.Vector
  52.    private Vector field_2;
  53.    // $FF: renamed from: v java.util.Vector
  54.    private Vector field_3;
  55.  
  56.    public TreeView() {
  57.       this.sbVTimer = -1L;
  58.       this.bgHighlightColor = Color.blue;
  59.       this.fgHighlightColor = Color.white;
  60.       this.viewHeight = 300;
  61.       this.viewWidth = 300;
  62.       this.cellSize = 16;
  63.       this.clickSize = 8;
  64.       this.imageInset = 3;
  65.       this.textInset = 6;
  66.       this.textBaseLine = 3;
  67.       this.doubleClickResolution = 333;
  68.       super.setLayout(new BorderLayout());
  69.       ((Container)this).add("East", this.sbV = new Scrollbar(1));
  70.    }
  71.  
  72.    public TreeView(TreeNode var1) {
  73.       this();
  74.       this.selectedNode = this.rootNode = var1;
  75.       this.count = 1;
  76.    }
  77.  
  78.    public void setBackground(Color var1) {
  79.       super.setBackground(var1);
  80.       ((Component)this).repaint();
  81.    }
  82.  
  83.    public Color getBackground() {
  84.       return super.getBackground();
  85.    }
  86.  
  87.    public void setForeground(Color var1) {
  88.       super.setForeground(var1);
  89.       ((Component)this).repaint();
  90.    }
  91.  
  92.    public Color getForeground() {
  93.       return super.getForeground();
  94.    }
  95.  
  96.    public void setFgHilite(Color var1) {
  97.       this.fgHighlightColor = var1;
  98.       ((Component)this).repaint();
  99.    }
  100.  
  101.    public Color getFgHilite() {
  102.       return this.fgHighlightColor;
  103.    }
  104.  
  105.    public void setBgHilite(Color var1) {
  106.       this.bgHighlightColor = var1;
  107.       ((Component)this).repaint();
  108.    }
  109.  
  110.    public Color getBgHilite() {
  111.       return this.bgHighlightColor;
  112.    }
  113.  
  114.    public void insert(TreeNode var1, TreeNode var2, int var3) {
  115.       if (var1 != null && var2 != null) {
  116.          if (this.exists(var2)) {
  117.             switch (var3) {
  118.                case 0:
  119.                   this.addChild(var1, var2);
  120.                   return;
  121.                case 1:
  122.                   this.addSibling(var1, var2, false);
  123.                   return;
  124.                case 2:
  125.                   this.addSibling(var1, var2, true);
  126.                   return;
  127.                default:
  128.             }
  129.          }
  130.       }
  131.    }
  132.  
  133.    public TreeNode getRootNode() {
  134.       return this.rootNode;
  135.    }
  136.  
  137.    public int getCount() {
  138.       return this.count;
  139.    }
  140.  
  141.    public int getViewCount() {
  142.       return this.viewCount;
  143.    }
  144.  
  145.    boolean viewable(TreeNode var1) {
  146.       for(int var2 = 0; var2 < this.viewCount; ++var2) {
  147.          if (var1 == this.field_3.elementAt(var2)) {
  148.             return true;
  149.          }
  150.       }
  151.  
  152.       return false;
  153.    }
  154.  
  155.    boolean viewable(String var1) {
  156.       if (var1 == null) {
  157.          return false;
  158.       } else {
  159.          for(int var2 = 0; var2 < this.viewCount; ++var2) {
  160.             TreeNode var3 = (TreeNode)this.field_3.elementAt(var2);
  161.             if (var3.text != null && var1.equals(var3.text)) {
  162.                return true;
  163.             }
  164.          }
  165.  
  166.          return false;
  167.       }
  168.    }
  169.  
  170.    public boolean exists(TreeNode var1) {
  171.       this.recount();
  172.  
  173.       for(int var2 = 0; var2 < this.count; ++var2) {
  174.          if (var1 == this.field_2.elementAt(var2)) {
  175.             return true;
  176.          }
  177.       }
  178.  
  179.       return false;
  180.    }
  181.  
  182.    public boolean exists(String var1) {
  183.       this.recount();
  184.       if (var1 == null) {
  185.          return false;
  186.       } else {
  187.          for(int var2 = 0; var2 < this.count; ++var2) {
  188.             TreeNode var3 = (TreeNode)this.field_2.elementAt(var2);
  189.             if (var3.text != null && var1.equals(var3.text)) {
  190.                return true;
  191.             }
  192.          }
  193.  
  194.          return false;
  195.       }
  196.    }
  197.  
  198.    public void append(TreeNode var1) {
  199.       if (this.rootNode == null) {
  200.          this.rootNode = var1;
  201.          this.selectedNode = this.rootNode;
  202.          this.count = 1;
  203.       } else {
  204.          this.addSibling(var1, this.rootNode, true);
  205.       }
  206.    }
  207.  
  208.    void addChild(TreeNode var1, TreeNode var2) {
  209.       if (var2.child == null) {
  210.          var2.child = var1;
  211.          var1.parent = var2;
  212.          ++this.count;
  213.       } else {
  214.          this.addSibling(var1, var2.child, true);
  215.       }
  216.  
  217.       ++var2.numberOfChildren;
  218.    }
  219.  
  220.    void addSibling(TreeNode var1, TreeNode var2) {
  221.       this.addSibling(var1, var2, true);
  222.    }
  223.  
  224.    void addSibling(TreeNode var1, TreeNode var2, boolean var3) {
  225.       if (var3) {
  226.          TreeNode var4;
  227.          for(var4 = var2; var4.sibling != null; var4 = var4.sibling) {
  228.          }
  229.  
  230.          var4.sibling = var1;
  231.       } else {
  232.          var1.sibling = var2.sibling;
  233.          var2.sibling = var1;
  234.       }
  235.  
  236.       var1.parent = var2.parent;
  237.       ++this.count;
  238.    }
  239.  
  240.    public TreeNode remove(String var1) {
  241.       this.recount();
  242.  
  243.       for(int var2 = 0; var2 < this.count; ++var2) {
  244.          TreeNode var3 = (TreeNode)this.field_2.elementAt(var2);
  245.          if (var3.text != null && var1.equals(var3.text)) {
  246.             this.remove(var3);
  247.             return var3;
  248.          }
  249.       }
  250.  
  251.       return null;
  252.    }
  253.  
  254.    public void removeSelected() {
  255.       if (this.selectedNode != null) {
  256.          this.remove(this.selectedNode);
  257.       }
  258.  
  259.    }
  260.  
  261.    public void remove(TreeNode var1) {
  262.       if (this.exists(var1)) {
  263.          if (var1 == this.selectedNode) {
  264.             int var2 = this.field_3.indexOf(this.selectedNode);
  265.             if (var2 == -1) {
  266.                var2 = this.field_2.indexOf(this.selectedNode);
  267.             }
  268.  
  269.             if (var2 > this.viewCount - 1) {
  270.                var2 = this.viewCount - 1;
  271.             }
  272.  
  273.             if (var2 > 0) {
  274.                this.changeSelection((TreeNode)this.field_3.elementAt(var2 - 1));
  275.             } else if (this.viewCount > 0) {
  276.                this.changeSelection((TreeNode)this.field_3.elementAt(1));
  277.             }
  278.          }
  279.  
  280.          if (var1.parent != null) {
  281.             if (var1.parent.child == var1) {
  282.                if (var1.sibling != null) {
  283.                   var1.parent.child = var1.sibling;
  284.                } else {
  285.                   var1.parent.child = null;
  286.                   var1.parent.collapse();
  287.                }
  288.             } else {
  289.                TreeNode var3;
  290.                for(var3 = var1.parent.child; var3.sibling != var1; var3 = var3.sibling) {
  291.                }
  292.  
  293.                if (var1.sibling != null) {
  294.                   var3.sibling = var1.sibling;
  295.                } else {
  296.                   var3.sibling = null;
  297.                }
  298.             }
  299.          } else if (var1 == this.rootNode) {
  300.             if (var1.sibling == null) {
  301.                this.rootNode = null;
  302.             } else {
  303.                this.rootNode = var1.sibling;
  304.             }
  305.          } else {
  306.             TreeNode var4;
  307.             for(var4 = this.rootNode; var4.sibling != var1; var4 = var4.sibling) {
  308.             }
  309.  
  310.             if (var1.sibling != null) {
  311.                var4.sibling = var1.sibling;
  312.             } else {
  313.                var4.sibling = null;
  314.             }
  315.          }
  316.  
  317.          this.recount();
  318.       }
  319.    }
  320.  
  321.    public void printTree(TreeNode var1) {
  322.       if (var1 != null) {
  323.          System.out.println(var1.text);
  324.          this.printTree(var1.child);
  325.          this.printTree(var1.sibling);
  326.       }
  327.    }
  328.  
  329.    private void recount() {
  330.       this.count = 0;
  331.       this.field_2 = new Vector();
  332.       if (this.rootNode != null) {
  333.          this.rootNode.depth = 0;
  334.          this.traverse(this.rootNode);
  335.       }
  336.  
  337.    }
  338.  
  339.    private void traverse(TreeNode var1) {
  340.       ++this.count;
  341.       this.field_2.addElement(var1);
  342.       if (var1.child != null) {
  343.          var1.child.depth = var1.depth + 1;
  344.          this.traverse(var1.child);
  345.       }
  346.  
  347.       if (var1.sibling != null) {
  348.          var1.sibling.depth = var1.depth;
  349.          this.traverse(var1.sibling);
  350.       }
  351.  
  352.    }
  353.  
  354.    private void resetVector() {
  355.       this.field_3 = new Vector(this.count);
  356.       this.viewWidest = 30;
  357.       if (this.count < 1) {
  358.          this.viewCount = 0;
  359.       } else {
  360.          this.rootNode.depth = 0;
  361.          this.vectorize(this.rootNode, true, this.field_3);
  362.          this.viewCount = this.field_3.size();
  363.       }
  364.    }
  365.  
  366.    private void vectorize(TreeNode var1, boolean var2, Vector var3) {
  367.       if (var1 != null) {
  368.          var3.addElement(var1);
  369.          if (!var2 && var1.child != null || var1.isExpanded()) {
  370.             var1.child.depth = var1.depth + 1;
  371.             this.vectorize(var1.child, var2, var3);
  372.          }
  373.  
  374.          if (var1.sibling != null) {
  375.             var1.sibling.depth = var1.depth;
  376.             this.vectorize(var1.sibling, var2, var3);
  377.          }
  378.  
  379.       }
  380.    }
  381.  
  382.    private void debugVector() {
  383.       this.field_3.size();
  384.  
  385.       for(int var1 = 0; var1 < this.count; ++var1) {
  386.          TreeNode var2 = (TreeNode)this.field_3.elementAt(var1);
  387.          System.out.println(var2.text);
  388.       }
  389.  
  390.    }
  391.  
  392.    public boolean handleEvent(Event var1) {
  393.       if (var1.target == this.sbV) {
  394.          if (var1.arg == null) {
  395.             return false;
  396.          }
  397.  
  398.          if (this.sbVPosition != (Integer)var1.arg) {
  399.             this.sbVPosition = (Integer)var1.arg;
  400.             this.redraw();
  401.          }
  402.       }
  403.  
  404.       return super.handleEvent(var1);
  405.    }
  406.  
  407.    public boolean mouseDown(Event var1, int var2, int var3) {
  408.       int var4 = var3 / this.cellSize + this.sbVPosition;
  409.       if (var4 > this.viewCount - 1) {
  410.          return false;
  411.       } else {
  412.          TreeNode var5 = this.selectedNode;
  413.          TreeNode var6 = (TreeNode)this.field_3.elementAt(var4);
  414.          int var7 = var6.getDepth();
  415.          this.changeSelection(var6);
  416.          Rectangle var8 = new Rectangle(this.cellSize * var7 + this.cellSize / 4, (var4 - this.sbVPosition) * this.cellSize + this.clickSize / 2, this.clickSize, this.clickSize);
  417.          if (var8.inside(var2, var3)) {
  418.             var6.toggle();
  419.             this.sendActionEvent(var1);
  420.             this.redraw();
  421.          } else {
  422.             if (var6 == var5 && var1.when - this.timeMouseDown < (long)this.doubleClickResolution) {
  423.                var6.toggle();
  424.                this.redraw();
  425.                this.sendActionEvent(var1);
  426.                return false;
  427.             }
  428.  
  429.             this.timeMouseDown = var1.when;
  430.          }
  431.  
  432.          return true;
  433.       }
  434.    }
  435.  
  436.    public boolean keyDown(Event var1, int var2) {
  437.       int var3 = this.field_3.indexOf(this.selectedNode);
  438.       switch (var2) {
  439.          case 10:
  440.             this.sendActionEvent(var1);
  441.             ((Component)this).requestFocus();
  442.             break;
  443.          case 1006:
  444.             if (this.selectedNode.isExpanded()) {
  445.                this.selectedNode.toggle();
  446.                this.redraw();
  447.                break;
  448.             }
  449.          case 1004:
  450.             if (var3 > 0) {
  451.                --var3;
  452.                this.changeSelection((TreeNode)this.field_3.elementAt(var3));
  453.                ((Component)this).requestFocus();
  454.             }
  455.             break;
  456.          case 1007:
  457.             if (this.selectedNode.isExpandable() && !this.selectedNode.isExpanded()) {
  458.                this.selectedNode.toggle();
  459.                this.sendActionEvent(var1);
  460.                this.redraw();
  461.                break;
  462.             } else if (!this.selectedNode.isExpandable()) {
  463.                break;
  464.             }
  465.          case 1005:
  466.             if (var3 < this.viewCount - 1) {
  467.                ++var3;
  468.                this.changeSelection((TreeNode)this.field_3.elementAt(var3));
  469.                ((Component)this).requestFocus();
  470.             }
  471.       }
  472.  
  473.       return false;
  474.    }
  475.  
  476.    private void sendActionEvent(Event var1) {
  477.       int var2 = var1.id;
  478.       Object var3 = var1.arg;
  479.       var1.id = 1001;
  480.       var1.arg = new String(this.selectedNode.getText());
  481.       ((Component)this).postEvent(var1);
  482.       var1.id = var2;
  483.       var1.arg = var3;
  484.    }
  485.  
  486.    public TreeNode getSelectedNode() {
  487.       return this.selectedNode;
  488.    }
  489.  
  490.    public String getSelectedText() {
  491.       return this.selectedNode == null ? null : this.selectedNode.getText();
  492.    }
  493.  
  494.    private void changeSelection(TreeNode var1) {
  495.       if (var1 != this.selectedNode) {
  496.          TreeNode var2 = this.selectedNode;
  497.          this.selectedNode = var1;
  498.          this.drawNodeText(var2, (this.field_3.indexOf(var2) - this.sbVPosition) * this.cellSize, true);
  499.          this.drawNodeText(var1, (this.field_3.indexOf(var1) - this.sbVPosition) * this.cellSize, true);
  500.          int var3 = this.field_3.indexOf(this.selectedNode);
  501.          ((Component)this).postEvent(new Event(this, 1006, this.selectedNode));
  502.          if (var3 < this.sbVPosition) {
  503.             --this.sbVPosition;
  504.             this.sbV.setValue(this.sbVPosition);
  505.             this.redraw();
  506.          } else if (var3 >= this.sbVPosition + (this.viewHeight - this.cellSize / 2) / this.cellSize) {
  507.             ++this.sbVPosition;
  508.             this.sbV.setValue(this.sbVPosition);
  509.             this.redraw();
  510.          } else {
  511.             ((Component)this).repaint();
  512.          }
  513.       }
  514.    }
  515.  
  516.    public void update(Graphics var1) {
  517.       this.paint(var1);
  518.    }
  519.  
  520.    public void paint(Graphics var1) {
  521.       Dimension var2 = ((Component)this).size();
  522.       if (var2.width == this.viewWidth && var2.height == this.viewHeight) {
  523.          if (Beans.isDesignTime()) {
  524.             this.resetVector();
  525.             ((Container)this).layout();
  526.             this.drawTree();
  527.          }
  528.       } else {
  529.          this.redraw();
  530.       }
  531.  
  532.       var1.drawImage(this.im1, 0, 0, this);
  533.    }
  534.  
  535.    public void redraw() {
  536.       this.resetVector();
  537.       if (this.viewCount > this.viewHeight / this.cellSize) {
  538.          this.sbV.setValues(this.sbVPosition, this.viewHeight / this.cellSize, 0, this.viewCount - 2);
  539.          this.sbV.setPageIncrement(1);
  540.          this.sbVWidth = this.sbV.preferredSize().width;
  541.          ((Component)this).getParent().paintAll(((Component)this).getParent().getGraphics());
  542.          this.sbV.show();
  543.          ((Container)this).layout();
  544.       } else {
  545.          this.sbV.hide();
  546.          this.sbVWidth = 1;
  547.          this.sbVPosition = 0;
  548.          ((Container)this).layout();
  549.       }
  550.  
  551.       this.drawTree();
  552.       ((Component)this).repaint();
  553.    }
  554.  
  555.    public void drawTree() {
  556.       Dimension var1 = ((Component)this).size();
  557.       if (var1.width != this.viewWidth || var1.height != this.viewHeight || this.field_1 == null) {
  558.          this.im1 = ((Component)this).createImage(var1.width, var1.height);
  559.          if (this.field_1 != null) {
  560.             this.field_1.dispose();
  561.          }
  562.  
  563.          this.field_1 = this.im1.getGraphics();
  564.          this.viewWidth = var1.width;
  565.          this.viewHeight = var1.height;
  566.       }
  567.  
  568.       Font var2 = ((Component)this).getFont();
  569.       if (var2 == null) {
  570.          var2 = new Font("TimesRoman", 0, 13);
  571.          this.field_1.setFont(var2);
  572.          ((Component)this).setFont(var2);
  573.       }
  574.  
  575.       if (var2 != null && this.field_1.getFont() == null) {
  576.          this.field_1.setFont(var2);
  577.       }
  578.  
  579.       this.field_0 = this.field_1.getFontMetrics();
  580.       this.field_1.setColor(this.getBackground());
  581.       this.field_1.fillRect(0, 0, this.viewWidth, this.viewHeight);
  582.       int var3 = this.sbVPosition + this.viewHeight / this.cellSize + 1;
  583.       if (var3 > this.viewCount) {
  584.          var3 = this.viewCount;
  585.       }
  586.  
  587.       TreeNode var4 = (TreeNode)this.field_3.elementAt(this.sbVPosition);
  588.  
  589.       for(int var5 = this.sbVPosition; var5 < var3; ++var5) {
  590.          TreeNode var6 = (TreeNode)this.field_3.elementAt(var5);
  591.          int var7 = this.cellSize * (var6.depth + 1);
  592.          int var8 = (var5 - this.sbVPosition) * this.cellSize;
  593.          this.field_1.setColor(this.getForeground());
  594.          if (var6.sibling != null) {
  595.             int var9 = this.field_3.indexOf(var6.sibling) - var5;
  596.             if (var9 > var3) {
  597.                var9 = var3;
  598.             }
  599.  
  600.             this.drawDotLine(var7 - this.cellSize / 2, var8 + this.cellSize / 2, var7 - this.cellSize / 2, var8 + this.cellSize / 2 + var9 * this.cellSize);
  601.          }
  602.  
  603.          for(int var11 = 0; var11 < var5; ++var11) {
  604.             TreeNode var10 = (TreeNode)this.field_3.elementAt(var11);
  605.             if (var10.sibling == var6 && var11 < this.sbVPosition) {
  606.                this.drawDotLine(var7 - this.cellSize / 2, 0, var7 - this.cellSize / 2, var8 + this.cellSize / 2);
  607.             }
  608.          }
  609.  
  610.          if (var6.isExpanded()) {
  611.             this.drawDotLine(var7 + this.cellSize / 2, var8 + this.cellSize - 2, var7 + this.cellSize / 2, var8 + this.cellSize + this.cellSize / 2);
  612.          }
  613.  
  614.          this.field_1.setColor(this.getForeground());
  615.          this.drawDotLine(var7 - this.cellSize / 2, var8 + this.cellSize / 2, var7 + this.cellSize / 2, var8 + this.cellSize / 2);
  616.          if (var6.isExpandable()) {
  617.             this.field_1.setColor(this.getBackground());
  618.             this.field_1.fillRect(this.cellSize * var6.depth + this.cellSize / 4, var8 + this.clickSize / 2, this.clickSize, this.clickSize);
  619.             this.field_1.setColor(this.getForeground());
  620.             this.field_1.drawRect(this.cellSize * var6.depth + this.cellSize / 4, var8 + this.clickSize / 2, this.clickSize, this.clickSize);
  621.             this.field_1.drawLine(this.cellSize * var6.depth + this.cellSize / 4 + 2, var8 + this.cellSize / 2, this.cellSize * var6.depth + this.cellSize / 4 + this.clickSize - 2, var8 + this.cellSize / 2);
  622.             if (!var6.isExpanded()) {
  623.                this.field_1.drawLine(this.cellSize * var6.depth + this.cellSize / 2, var8 + this.clickSize / 2 + 2, this.cellSize * var6.depth + this.cellSize / 2, var8 + this.clickSize / 2 + this.clickSize - 2);
  624.             }
  625.          }
  626.  
  627.          Image var12 = var6.getImage();
  628.          if (var12 != null) {
  629.             this.field_1.drawImage(var12, var7 + this.imageInset, var8, this);
  630.          }
  631.  
  632.          if (var6.text != null) {
  633.             this.drawNodeText(var6, var8, var6 == this.selectedNode);
  634.          }
  635.  
  636.          if (var4.depth > var6.depth) {
  637.             var4 = var6;
  638.          }
  639.       }
  640.  
  641.       while((var4 = var4.parent) != null) {
  642.          if (var4.sibling != null) {
  643.             this.drawDotLine(this.cellSize * (var4.depth + 1) - this.cellSize / 2, 0, this.cellSize * (var4.depth + 1) - this.cellSize / 2, var1.height);
  644.          }
  645.       }
  646.  
  647.       this.field_1.setColor(this.getForeground());
  648.       this.field_1.drawRect(0, 0, this.viewWidth - this.sbVWidth, this.viewHeight - 1);
  649.    }
  650.  
  651.    private void drawNodeText(TreeNode var1, int var2, boolean var3) {
  652.       int var6 = var1.depth;
  653.       Image var7 = var1.getImage();
  654.       int var8 = (var6 + 1) * this.cellSize + this.cellSize + this.textInset - (var7 == null ? 12 : 0);
  655.       Color var4;
  656.       Color var5;
  657.       if (var1 == this.selectedNode) {
  658.          var4 = this.fgHighlightColor;
  659.          var5 = this.bgHighlightColor;
  660.       } else {
  661.          var4 = this.getForeground();
  662.          var5 = this.getBackground();
  663.       }
  664.  
  665.       if (var3) {
  666.          this.field_1.setColor(var5);
  667.          this.field_1.fillRect(var8 - 1, var2 + 1, this.field_0.stringWidth(var1.text) + 4, this.cellSize - 1);
  668.       }
  669.  
  670.       this.field_1.setColor(var4);
  671.       this.field_1.drawString(var1.text, var8, var2 + this.cellSize - this.textBaseLine);
  672.    }
  673.  
  674.    private void drawDotLine(int var1, int var2, int var3, int var4) {
  675.       if (var2 == var4) {
  676.          for(int var6 = var1; var6 < var3; var6 += 2) {
  677.             this.field_1.drawLine(var6, var2, var6, var4);
  678.          }
  679.  
  680.       } else {
  681.          for(int var5 = var2; var5 < var4; var5 += 2) {
  682.             this.field_1.drawLine(var1, var5, var3, var5);
  683.          }
  684.  
  685.       }
  686.    }
  687.  
  688.    public void setTreeStructure(String[] var1) {
  689.       this.rootNode = this.selectedNode = null;
  690.  
  691.       try {
  692.          this.parseTreeStructure(var1);
  693.       } catch (InvalidTreeNodeException var3) {
  694.          System.out.println(var3);
  695.       }
  696.  
  697.       ((Component)this).invalidate();
  698.    }
  699.  
  700.    public String[] getTreeStructure() {
  701.       Vector var1 = new Vector(this.count);
  702.       this.rootNode.depth = 0;
  703.       this.vectorize(this.rootNode, false, var1);
  704.       int var2 = var1.size();
  705.       String[] var3 = new String[var2];
  706.  
  707.       for(int var4 = 0; var4 < var2; ++var4) {
  708.          TreeNode var5 = (TreeNode)var1.elementAt(var4);
  709.          String var6 = "";
  710.  
  711.          for(int var7 = 0; var7 < var5.depth; ++var7) {
  712.             var6 = var6 + ' ';
  713.          }
  714.  
  715.          var6 = var6 + var5.text;
  716.          var3[var4] = var6;
  717.       }
  718.  
  719.       return var3;
  720.    }
  721.  
  722.    private void parseTreeStructure(String[] var1) throws InvalidTreeNodeException {
  723.       for(int var2 = 0; var2 < var1.length; ++var2) {
  724.          String var3 = var1[var2];
  725.          int var4 = this.findLastPreSpace(var3);
  726.          if (var4 == -1) {
  727.             throw new InvalidTreeNodeException();
  728.          }
  729.  
  730.          if (this.rootNode == null) {
  731.             if (var4 != 0) {
  732.                throw new InvalidTreeNodeException();
  733.             }
  734.  
  735.             TreeNode var5 = new TreeNode(var3.trim());
  736.             var5.setDepth(var4);
  737.             this.append(var5);
  738.          } else {
  739.             TreeNode var9 = this.rootNode;
  740.  
  741.             for(int var6 = 1; var6 < var4; ++var6) {
  742.                int var7 = var9.numberOfChildren;
  743.                TreeNode var8 = null;
  744.                if (var7 > 0) {
  745.                   for(var8 = var9.child; var8.sibling != null; var8 = var8.sibling) {
  746.                   }
  747.                }
  748.  
  749.                if (var8 == null) {
  750.                   break;
  751.                }
  752.  
  753.                var9 = var8;
  754.             }
  755.  
  756.             int var10 = var4 - var9.getDepth();
  757.             if (var10 > 1) {
  758.                throw new InvalidTreeNodeException();
  759.             }
  760.  
  761.             TreeNode var11 = new TreeNode(var3.trim());
  762.             var11.setDepth(var4);
  763.             if (var10 == 1) {
  764.                this.insert(var11, var9, 0);
  765.             } else {
  766.                this.insert(var11, var9, 1);
  767.             }
  768.          }
  769.       }
  770.  
  771.    }
  772.  
  773.    private int findLastPreSpace(String var1) {
  774.       int var2 = var1.length();
  775.       if (var1.charAt(0) != ' ' && var1.charAt(0) != '\t') {
  776.          return 0;
  777.       } else {
  778.          for(int var3 = 1; var3 < var2; ++var3) {
  779.             if (var1.charAt(var3) != ' ' && var1.charAt(var3) != '\t') {
  780.                return var3;
  781.             }
  782.          }
  783.  
  784.          return -1;
  785.       }
  786.    }
  787.  
  788.    public synchronized Dimension preferredSize() {
  789.       return new Dimension(175, 125);
  790.    }
  791.  
  792.    public synchronized Dimension minimumSize() {
  793.       return new Dimension(50, 50);
  794.    }
  795.  
  796.    public void setLayout(LayoutManager var1) {
  797.    }
  798. }
  799.